//============================== HTM_DB.ixx ==============================
//Hash Tree Mash Database

//概述

//编写规范
/*
1.各种名字中：
    - htm private
		- 结构体 xxx_
		- 变量   xxx__ 
		- 类      _xxx
		- 函数   __xxx
		//只需要在最外边这么写，内部的东西不应有额外的“前置”或“后置”下划线

2.所有全局访问数据结构体本身使用unique_ptr管理，内部加锁
3.各种名字尽量使用小写，常量使用大写，所有生命周期不确定的地方使用弱指针
4.

*/

export module HTM_DB;

import <any>;
import <array>;
import <atomic>;
import <algorithm>;
import <chrono>;
import <cctype>;
import <cstring>;
import <cassert>;
import <condition_variable>;
import <format>;
import <functional>;
import <iomanip>;
import <iostream>;
import <map>;
import <mutex>;
import <memory>;
import <queue>;
import <set>;
import <span>;
import <string>;
import <sstream>;
import <stdexcept>;
import <shared_mutex>;
import <thread>;
import <utility>;
import <unordered_map>;
import <vector>;

namespace htm_db_namespace {

	export class htm {
	public:
		enum class enum_OPT {

		};
		enum class enum_user_type {
			su = 0,//超级管理员，无视任何锁（除了共享锁该等待还是要等待）
			hu = 1,//高级管理员
            cu = 2,//普通用户
			vu = 3,//访客
			no_init = 4
		};
		enum class enum_permission {
			rw = 0,
			r_ = 1,
			__ = 2,
			no_init = 3
		};
		enum class enum_listen_type {
			global = 0, //全局监听
			node = 1,   //节点监听
			pass = 2,   //经过型监听
			all = 3     //任意类型监听(仅在遍历列举时使用)
		};
		enum class enum_data_base_lock_type {
			lock_all_operation                     = 0,//锁定所有操作
			lock_all_user_authorization_operation  = 1,//禁用用户管理
			lock_all_user_permission_operation     = 2,//禁用权限设置
			lock_all_write_node_operation          = 3,//禁用读节点
			lock_all_read_and_write_node_operation = 4,//禁用写节点
			lock_all_crud_fast_operation           = 5,//禁用高速访问
			lock_all_not_su_listen_operation       = 6,//禁用监听，监听在某些情况下过于强大，可能带来不安全
			lock_all_restore_recycled_operation    = 7,//禁用回收站
			lock_all_tool_operation                = 8,//禁用工具
			lock_all_log_operation                 = 9//禁用日志获取，在某些情况下防止信息泄露
		};
		struct     struct_operation_info_bag {
			std::string user_father;
			std::string user;
			enum_OPT operation_type;
			bool is_pass_listen;
			std::vector<std::string> path;
			std::string begining_path;
			std::string ending_path;
			size_t between_path_lenth;  //等于1时表示 /begining/*/ending，等于2时表示 /begining/*/*/ending，等于0时表示无通配监听
			std::vector<std::string> target_path;
			std::string new_key;
			std::any new_value;      //仅基本数据类型可用，复杂类型不允许传入，避免导致过多占用数据空间
			std::string search_key;  //仅基本数据类型可用，复杂类型不允许传入，避免导致过多占用数据空间
		};

	private:

		//===== 基本数据 =====

		//=== 用户 ===
		//用户等级与权限变更信息(需要操作溯源时可使用)
		struct user_change_info_ {
			//变更时间
			long long int change_time = 0;
			//变更详情
			enum_user_type old_user_type = enum_user_type::no_init;
			enum_user_type new_user_type = enum_user_type::no_init;
			std::string old_username = "";
			std::string new_username = "";
			//变更原因
			std::string change_reason = "";
		};

		//使用struct 定义token以便于扩展
		struct token_info_ {
			//使用string为了在本地运算和可科学计算时简单和高效，并且便于哈希查找，实际可以根据业务情况调整（注意调整token校验方法）
			std::string main_key = "";
		};

        struct character_tag_permission_info_ {
            struct node_permission_tag_info {
                bool     permission_is_recursive;//是否向下传播
                enum_permission permission = enum_permission::no_init;
                std::vector<std::vector<long long int>> time_permission_window;//离散时间区间权限
            };

            string tag = "";
            enum_permission global_permisssion = enum_permission::no_init;
            std::map<string, node_permission_tag_info> path_permission;
        };
        
        struct node_tag_permission_info_ {
            std::string tag = "";
            enum_permission permission = enum_permission::no_init;
        };

		struct global_user_info_ {

			//===== 生命周期安全 =====
			//引用计数
			std::atomic<int> using_count = 0;
            //等待写入标识
            std::atomic<bool> will_change = false;
			//弃用
			std::atomic<bool> is_deprecated = false;
			//锁
			std::shared_mutex lock;

			//===== 线程安全 =====
			//防止未授权的线程访问
			//已授权线程ID
			std::atomic<bool> this_user_only_can_be_one_thread_keep = false;

			std::unique_ptr<std::set<std::thread::id>> authorizated_threads = nullptr;

			//===== 基本信息 =====
			//用户类型
			enum_user_type user_type = enum_user_type::no_init;
			//用户ID
			long long int user_id = 0;

			//用户全局权限
			enum_permission global_permission = enum_permission::no_init;
			//用户节点权限索引(指向内存池以使内存整齐，避免不必要的哈希表创建)
			std::unique_ptr<std::unordered_map<std::string, std::vector<std::string>>> node_permission_index = nullptr;

            //===== 标签信息 =====
            //角色属性访问控制
            //tag-character_tag_permission_info_
            std::unique_ptr<std::map<string,character_tag_permission_info_>> character_tag_sat_for_child_users;
            std::unique_ptr<std::map<string,character_tag_permission_info_>> this_user_authorized_character_tags_and_permissions;

            //资源属性访问控制
            std::unique_ptr<std::map<string,node_tag_permission_info_>> node_tag_sat_for_child_users;
            std::unique_ptr<std::map<string,node_tag_permission_info_>> this_user_authorized_node_tags_and_permissions;

            //工作路径信息(非法访问O(n)弹出，防路径遍历攻击)
            std::atomic<bool> turn_on_working_path_authorized_permission = false;
            std::unique_ptr<std::sat<std::vector<std::string>>> authorized_working_path_vector_sat = {};
            std::unique_ptr<std::unordered_map<std::string, int>>> authorized_working_path_string_sat = {};//当使用string路径时可以O(1)弹出非法操作

			//===== 登录信息 =====
			//用户名
			std::string username = "";
			//token
			token_info_ token;

            //子用户权限
            enum_permission all_not_actually_set_permission_child_user_using_this_permission = enum_permission::no_init;

			
			//创建时间
			long long int create_time = 0;
			//最后登录时间（超出一定时间后需要刷新token）
			long long int last_login_time = 0;

			//修改时间与变更情况
			std::atomic<bool> open_write_down_chenge_info = false;
			std::vector<user_change_info_> change_info_history;

			//子用户(指向内存池以使内存整齐，避免不必要的哈希表创建)
			std::unique_ptr<std::unordered_map<std::string, std::shared_ptr<global_user_info_>>> child_users = nullptr;

			//构造函数
			global_user_info_();
			//析构函数
			~global_user_info_();
		};

		struct node_user_info_ {
			std::weak_ptr<node_user_info_> user_father_info;
			enum_permission user_permission;
            bool            permission_is_recursive;//是否向下传播
            std::vector<std::vector<long long int>> time_permission_window;//离散时间区间权限
            enum_permission all_not_actually_set_permission_child_user_using_this_permission = enum_permission::no_init;//hu可定义
			std::unique_ptr<std::unordered_map<long long int, node_user_info_>> child_visitor_users = nullptr;
		};

		//全局用户树
		
		//使用智能指针以确保内存安全（不被复制，自动释放）
		//用户树根节点
		struct user_family_tree_ {
			std::shared_mutex lock;
			std::unique_ptr<global_user_info_> user_family_tree;
		};
		std::unique_ptr<user_family_tree_> user_family_tree__;
		
		//token - user_father - user映射表
		struct token_to_user_famly_info_ {
			std::shared_mutex lock;
			//使用弱指针跳转就不需要负责同步安全
			std::weak_ptr<global_user_info_> user_ptr;
			std::weak_ptr<global_user_info_> user_father_ptr;
		};
		
		struct token_to_user_relationship_ {
			std::shared_mutex lock;
			//key现在的string对应token_info中的main_key，纯粹为了简单和高效，实际可以根据业务情况调整
			std::unordered_map<std::string, std::shared_ptr<token_to_user_famly_info_>> ttur;
		};

		std::unique_ptr <token_to_user_relationship_> token_to_user_relationship__;

        //权限缓存
        struct user_permission_cache_ {
            enum_permission global_permission_cache;
            std::unique_ptr < std::unordered_map<std::string, enum_permission>> path_permission_cache;
        };

        struct permission_cache_ {
            //锁
            std::shared_mutex lock;
            std::atomic<int> using_count = 0;

            //权限缓存
            ////path-token-permission_cache
            std::unique_ptr < 
                std::unordered_map<std::string,     //path
                    std::unordered_map<std::string, //token
                        user_permission_cache_      //cache
                    >
                >
            > users_permission_cache;
        };

		//=== 数据库锁 ===
		struct data_base_lock_ {
			std::shared_mutex lock;
			//用户锁
			std::unique_ptr < std::unordered_map<long long int, std::vector<enum_data_base_lock_type>>> user_globe_locks;
		};
		
		std::unique_ptr<data_base_lock_> data_base_lock__;

		//=== 拦截 ===

		//=== 回调 ===
		//用户监听器数量配额
		struct     user_listen_num_control_ {
			std::shared_mutex smtx;  // 共享锁
			int max_listen_num    = 10000000;
			int su_max_listen_num = 100000;
			int hu_max_listen_num = 10000;
			int vu_max_listen_num = 1000;
			int quotal_num        = 0;
			int su_quotal_num     = 0;
			int hu_quotal_num     = 0;
			int vu_quotal_num     = 0;
		};

		std::unique_ptr<user_listen_num_control_> user_listen_num_control__;

		struct     listen_info_ {
			long long int listen_id;
			bool is_work;
			bool is_disposable;
			enum_listen_type listen_type;
			enum_OPT listen_operation_type;
			std::vector<std::vector<std::string>> permission_time_list;

			// 数据存储
			std::vector<std::any> vector_listen_data;

			// 回调函数
			std::function<void(struct_operation_info_bag op_bag, std::any old_value, std::vector<std::any>&) > callback;
		};

		//=== 节点 ===
		enum class lock_type_ {
			write = 0,
			read = 1,
			unlock = 2
		};

		struct     Node {
			//节点信息存储结构
			struct node_info {
				std::shared_mutex smtx;                                         // 共享锁
				std::atomic<lock_type_> lock_type{ lock_type_::unlock };        // 锁状态记录
				std::atomic<int> lock_count{ 0 };                               // 锁计数

				bool is_dict;                            // 节点类型标识
				long long int node_id;                   // 节点唯一标识符

				// 权限信息表
				// 仅仅存有hu和vu的信息
				std::unique_ptr<std::unordered_map<long long int, node_user_info_>> users_permission;

				//监听器存储
				std::unique_ptr <
					std::unordered_map<long long int,        //被监听者ID
						std::unordered_map<int,              //操作类型
							std::unordered_map<long long int,//监听ID
								listen_info_
							>
						>
					> 
				> listens;
                
                //基于tag的资源属性访问控制(仅对子用户生效)
                //user_id-tag
                std::map<long long int, string> node_tag;


				//时间戳
				//创建时间
				long long create_time;
				//修改时间
				long long update_time;
				//删除时间
				long long del_time;

				std::string key;            // 键
				std::any    value;          // 值
				std::unique_ptr <std::unordered_map<std::string, std::shared_ptr<Node>>> children;    // 子节点
				std::unique_ptr <std::unordered_map<std::string, std::shared_ptr<Node>>> del_children;
			};

			// 原子操作部分
            std::atomic<bool> will_change    = false;// 等待写入标识
			std::atomic<bool> is_intercepted = false;// 操作拦截标识（仅su）
			std::atomic<bool> is_broken      = false;// 弃用标识（仅su_hu）
			std::atomic<bool> is_locked      = false;// SU锁（仅su）

			//操作计数
			std::atomic<int> node_op_counter_{ 0 };

			node_info info;

			Node();

			~Node();
		};

		//===== 根节点==============
		std::unique_ptr<Node> root_node__;

		//内存池

		//回收站

		//日志

		//时间

		//线程池

		//析构函数
		~htm();
	};
};
//2025/09/06 注意：触发回调时要同时检查any类型和自己对应的操作类型的监听是否有，并且根据情况分别触发
//2025/9/14  主意：可以在节点上设置tag，实现属性控制访问